//! MetaTests.debug.js
//

(function() {

Type.registerNamespace('MetaPages.Classes');

////////////////////////////////////////////////////////////////////////////////
// Test

Test = function Test(name) {
    /// <param name="name" type="String">
    /// </param>
    /// <field name="defaultTestSpeed" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="waitSleep" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="maxWait" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="hasContent" type="String" static="true">
    /// </field>
    /// <field name="isEmpty" type="String" static="true">
    /// </field>
    /// <field name="isNumber" type="String" static="true">
    /// </field>
    /// <field name="askOkBtn" type="String" static="true">
    /// </field>
    /// <field name="askCancelBtn" type="String" static="true">
    /// </field>
    /// <field name="testSpeed" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_indent$1" type="String" static="true">
    /// </field>
    /// <field name="_savedSpeeds$1" type="Array" static="true">
    /// </field>
    /// <field name="testUserId" type="String" static="true">
    /// </field>
    /// <field name="testVars" type="Object" static="true">
    /// </field>
    /// <field name="_rxNumber$1" type="RegExp" static="true">
    /// </field>
    /// <field name="_instances$1" type="Object" static="true">
    /// </field>
    /// <field name="name" type="String">
    /// </field>
    /// <field name="lastSelect" type="jQueryObject">
    /// </field>
    /// <field name="_suite" type="TestSuite">
    /// </field>
    /// <field name="_endStep$1" type="Number" integer="true">
    /// </field>
    /// <field name="_endTime$1" type="Number" integer="true">
    /// </field>
    /// <field name="_overtime$1" type="Number" integer="true">
    /// </field>
    /// <field name="_skipCnt$1" type="Number" integer="true">
    /// </field>
    /// <field name="_startStep$1" type="Number" integer="true">
    /// </field>
    /// <field name="_startTime$1" type="Number" integer="true">
    /// </field>
    Test.initializeBase(this);
    this.name = name;
    TestInstance.theTest = this;
}
Test.addInstance = function Test$addInstance(cls) {
    /// <param name="cls" type="Object">
    /// </param>
    Test._instances$1[Type.getInstanceType(cls).get_fullName()] = cls;
}
Test.getInstance = function Test$getInstance(type) {
    /// <param name="type" type="Type">
    /// </param>
    /// <returns type="Object"></returns>
    return Test._instances$1[type.get_fullName()];
}
Test.setVar = function Test$setVar(key, v) {
    /// <param name="key" type="String">
    /// </param>
    /// <param name="v" type="Object">
    /// </param>
    key = (key.substr(0, 1) === '@') ? key.substr(1) : key;
    Test.testVars[key] = v;
}
Test.prototype = {
    name: null,
    lastSelect: null,
    _suite: null,
    _endStep$1: 0,
    _endTime$1: 0,
    _overtime$1: 0,
    _skipCnt$1: 0,
    _startStep$1: 0,
    _startTime$1: 0,
    
    get_testTime: function Test$get_testTime() {
        /// <value type="String"></value>
        return ((this._endTime$1 - this._startTime$1) / 1000).toPrecision(4);
    },
    
    addToSuite: function Test$addToSuite(suite) {
        /// <param name="suite" type="TestSuite">
        /// </param>
        /// <returns type="Test"></returns>
        suite.tests[this.name.toLowerCase()] = this;
        return this;
    },
    
    reset: function Test$reset() {
        /// <returns type="Test"></returns>
        this._startTime$1 = this._endTime$1 = new Date().getTime();
        this.lastSelect = null;
        this._overtime$1 = 0;
        Test.testSpeed = 1;
        Test._savedSpeeds$1 = [];
        TestSuite.tell(null);
        return this;
    },
    
    runTest: function Test$runTest(awp) {
        /// <param name="awp" type="Await">
        /// </param>
        /// <returns type="Test"></returns>
        if (ss.isNullOrUndefined(awp)) {
            this.addDx(ss.Delegate.create(this, function() {
                this._endTime$1 = new Date().getTime();
                var msg = String.format('<b>Test Passed</b> - run time = {0}s', this.get_testTime());
                Inform.log(msg);
                TestSuite.tell(msg).addClass('Passed').removeClass('Failed');
            }));
        }
        else {
            this.addDx(function(aw) {
                var taw = aw;
                var tawp = awp;
                tawp.lastSelect = taw.lastSelect;
            });
        }
        this.commit(awp);
        return this;
    },
    
    _testFailed$1: function Test$_testFailed$1() {
        this._endTime$1 = new Date().getTime();
        var msg = String.format('<b>Test Failed</b> - run time = {0}s', this.get_testTime());
        Inform.error(msg);
        TestSuite.tell(msg).addClass('Failed').removeClass('Passed');
    },
    
    _isValid$1: function Test$_isValid$1(a, b) {
        /// <param name="a" type="Object">
        /// </param>
        /// <param name="b" type="Object">
        /// </param>
        /// <returns type="Boolean"></returns>
        var aS = (ss.isValue(a)) ? a.toString() : null;
        var bS = (ss.isValue(b)) ? b.toString() : null;
        if (bS != null) {
            switch (bS) {
                case '[HasContent]':
                    return !String.isNullOrEmpty(aS);
                case '[IsEmpty]':
                    return String.isNullOrEmpty(aS);
                case '[IsNumber]':
                    return Test._rxNumber$1.test(aS);
            }
        }
        return aS === bS;
    },
    
    call: function Test$call(t, dict) {
        /// <param name="t" type="Test">
        /// </param>
        /// <param name="dict" type="Object">
        /// </param>
        /// <returns type="Test"></returns>
        this.addDl(ss.Delegate.create(this, function(aw) {
            if (this._skipCnt$1 > 0) {
                aw.done();
                return;
            }
            if (typeof(t) === 'string') {
                var nm = t;
                t = this._suite.tests[nm.toLowerCase()];
                if (t == null) {
                    throw new Error(Exceptions.invalidTestCaseName);
                }
            }
            t.reset();
            if (dict != null) {
                var $dict1 = dict;
                for (var $key2 in $dict1) {
                    var p = { key: $key2, value: $dict1[$key2] };
                    Test.setVar(p.key, p.value);
                }
            }
            t.runTest(aw);
        }));
        return this;
    },
    
    delay: function Test$delay(ms) {
        /// <param name="ms" type="Number" integer="true">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('Delay', ms, ss.Delegate.create(this, function() {
            window.setTimeout(ss.Delegate.create(this, function() {
                this.done();
            }), ms);
        }));
    },
    
    speed: function Test$speed(ms) {
        /// <param name="ms" type="Number" integer="true">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('Speed', ms, ss.Delegate.create(this, function() {
            if (arguments.length > 0) {
                Test._savedSpeeds$1.add(Test.testSpeed);
                Test.testSpeed = ms;
            }
            else {
                Test.testSpeed = Test._savedSpeeds$1[Test._savedSpeeds$1.length - 1];
                Test._savedSpeeds$1.removeAt(Test._savedSpeeds$1.length - 1);
            }
            this.nextTest();
        }));
    },
    
    step: function Test$step(name, arg1, arg2, fn, skipFn) {
        /// <param name="name" type="String">
        /// </param>
        /// <param name="arg1" type="String">
        /// </param>
        /// <param name="arg2" type="Object">
        /// </param>
        /// <param name="fn" type="System.Action`1">
        /// </param>
        /// <param name="skipFn" type="Function">
        /// </param>
        /// <returns type="Test"></returns>
        var aName = (arguments.length > 1) ? name : '';
        var aArg1 = (arguments.length > 2) ? arg1 : '';
        var aArg2 = (arguments.length > 3) ? arg2 : null;
        switch (arguments.length) {
            case 1:
                fn = arguments[0];
                break;
            case 2:
                fn = arguments[1];
                break;
            case 3:
                fn = arguments[2];
                break;
        }
        this.addDl(ss.Delegate.create(this, function(aw) {
            var log = (aArg2 != null) ? String.format('.{0}("{1}", "{2}")', aName, this.eq(aArg1), this.eq(aArg2)) : String.format('.{0}("{1}")', aName, this.eq(aArg1));
            if (this._skipCnt$1 > 0) {
                if (skipFn != null) {
                    skipFn();
                }
                aw.done();
                return;
            }
            Inform.log(log);
            TestSuite.tell(log).removeClass('Passed').removeClass('Failed');
            this._overtime$1 = new Date().getTime() + 10000;
            this._startStep$1 = new Date().getTime();
            fn(aw);
            this._endStep$1 = new Date().getTime();
        }));
        return this;
    },
    
    nextTest: function Test$nextTest() {
        /// <returns type="Test"></returns>
        window.setTimeout(ss.Delegate.create(this, function() {
            this.done();
        }), Test.testSpeed);
        return this;
    },
    
    goTo: function Test$goTo(page) {
        /// <param name="page" type="String">
        /// </param>
        /// <returns type="Test"></returns>
        return this.waitIO().step('GoTo', page, ss.Delegate.create(this, function() {
            Master.GoPage(this.eq(page).toString());
            this.nextTest();
        })).waitIO();
    },
    
    runPageSuite: function Test$runPageSuite(suite) {
        /// <param name="suite" type="String">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('RunSuite', suite, ss.Delegate.create(this, function() {
            TestSuite.getTestSuiteByPage(suite).runAllAw(this);
        }));
    },
    
    requireTestUser: function Test$requireTestUser() {
        /// <returns type="Test"></returns>
        return this.step('RequireTestUser', ss.Delegate.create(this, function() {
            var id = Nsb.Storage.getLocal(Test.testUserId);
            if (!ss.isValue(id)) {
                this._testFailed$1();
            }
            else {
                this.nextTest();
            }
        }));
    },
    
    waitIO: function Test$waitIO() {
        /// <returns type="Test"></returns>
        return this.sleep(10).addDl(ss.Delegate.create(this, function() {
            this._waitIOAction$1();
        })).sleep(10);
    },
    
    _waitIOAction$1: function Test$_waitIOAction$1() {
        if (FileBlobBase.svCnt > 0) {
            window.setTimeout(ss.Delegate.create(this, this._waitIOAction$1), 13);
        }
        else {
            this.done();
        }
    },
    
    waitFor: function Test$waitFor(select, value) {
        /// <param name="select" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('WaitFor', select, value, ss.Delegate.create(this, function() {
            this._waitForAction$1(select, value);
        }));
    },
    
    _waitForAction$1: function Test$_waitForAction$1(select, value) {
        /// <param name="select" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        select = this.eq(select);
        value = this.eq(value);
        var el;
        var ic;
        if (ss.isValue(value)) {
            el = null;
            var eel = $(select);
            eel.each(ss.Delegate.create(this, function(i, ee) {
                var ths = $(ee);
                if (this._isValid$1(ths.getFValue(), value)) {
                    el = ths;
                    return false;
                }
                return true;
            }));
            ic = el != null;
        }
        else {
            el = $(select);
            ic = el.length > 0 && el.is(':visible');
        }
        if (ic) {
            this.lastSelect = el;
            this.nextTest();
        }
        else {
            if (new Date().getTime() >= this._overtime$1) {
                this._testFailed$1();
                return;
            }
            window.setTimeout(ss.Delegate.create(this, function() {
                this._waitForAction$1(select, value);
            }), 13);
        }
    },
    
    waitNot: function Test$waitNot(select, value) {
        /// <param name="select" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('WaitNot', select, value, ss.Delegate.create(this, function() {
            this._waitNotAction$1(select, value);
        }));
    },
    
    _waitNotAction$1: function Test$_waitNotAction$1(select, value) {
        /// <param name="select" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        select = this.eq(select);
        value = this.eq(value);
        var el;
        var ic;
        if (ss.isValue(value)) {
            el = null;
            var eel = $(select);
            eel.each(ss.Delegate.create(this, function(i, ee) {
                var ths = $(ee);
                if (this._isValid$1(ths.getFValue(), value)) {
                    el = ths;
                    return false;
                }
                return true;
            }));
            ic = el == null;
        }
        else {
            el = $(select);
            ic = !el.length;
        }
        if (ic) {
            this.nextTest();
        }
        else {
            if (new Date().getTime() >= this._overtime$1) {
                this._testFailed$1();
                return;
            }
            window.setTimeout(ss.Delegate.create(this, function() {
                this._waitNotAction$1(select, value);
            }), 13);
        }
    },
    
    doIf: function Test$doIf(select, value, timeout) {
        /// <param name="select" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <param name="timeout" type="Number" integer="true">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('DoIf', select, value, ss.Delegate.create(this, function() {
            this._ifAction$1(select, value, timeout);
        }), ss.Delegate.create(this, function() {
            this._skipCnt$1++;
        }));
    },
    
    _ifAction$1: function Test$_ifAction$1(select, value, timeout) {
        /// <param name="select" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <param name="timeout" type="Number" integer="true">
        /// </param>
        value = this.eq(value);
        timeout = (timeout || 0);
        timeout = (timeout < 1000000) ? new Date().getTime() + timeout : timeout;
        var el;
        var ic;
        if (ss.isValue(value)) {
            el = null;
            var eel = $(select);
            eel.each(ss.Delegate.create(this, function(i, ee) {
                var ths = $(ee);
                if (this._isValid$1(ths.getFValue(), value)) {
                    el = ths;
                    return false;
                }
                return true;
            }));
            ic = el != null;
        }
        else {
            el = $(select);
            ic = el.length > 0;
        }
        if (ic) {
            this.lastSelect = el;
        }
        else {
            if (new Date().getTime() < timeout) {
                window.setTimeout(ss.Delegate.create(this, function() {
                    this._ifAction$1(select, value, timeout);
                }), 13);
                return;
            }
            this._skipCnt$1++;
        }
        this.nextTest();
    },
    
    endIf: function Test$endIf() {
        /// <returns type="Test"></returns>
        return this.addDx(ss.Delegate.create(this, function() {
            this._skipCnt$1--;
            if (this._skipCnt$1 <= 0) {
                Inform.log('.EndIf()');
                this._skipCnt$1 = 0;
            }
        }));
    },
    
    set: function Test$set(key, value) {
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Test"></returns>
        var type = typeof(value);
        return this.step('Set', key, value, ss.Delegate.create(this, function() {
            var v = value;
            if (type === 'function') {
                var fn = value;
                v = fn();
            }
            Test.setVar(key, v);
            this.done();
        }));
    },
    
    eq: function Test$eq(name) {
        /// <param name="name" type="Object">
        /// </param>
        /// <returns type="Object"></returns>
        if (name != null) {
            if (typeof(name) === 'function') {
                name = name();
            }
            var nm = name.toString();
            if (nm.substr(0, 1) === '@') {
                return Test.testVars[nm.substr(1)];
            }
        }
        return name;
    },
    
    setUser: function Test$setUser(id) {
        /// <param name="id" type="String">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('SetUser', id, ss.Delegate.create(this, function() {
            Nsb.Storage.setLocal(Test.testUserId, this.eq(id));
            Master.GoPage(ThemeYoshi.currentPageName);
            this.nextTest();
        }));
    },
    
    actionDl: function Test$actionDl(fn) {
        /// <param name="fn" type="Awaiter.Function">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('ActionDl', fn.toString().substr(12, 80), ss.Delegate.create(this, function() {
            fn(this);
        }));
    },
    
    actionDx: function Test$actionDx(fn) {
        /// <param name="fn" type="Awaiter.Function">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('ActionDx', fn.toString().substr(12, 80), ss.Delegate.create(this, function() {
            fn(this);
            this.nextTest();
        }));
    },
    
    enter: function Test$enter(arg1) {
        /// <param name="arg1" type="String">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('Enter', arg1, ss.Delegate.create(this, function() {
            if (this.lastSelect == null) {
                this.abort();
            }
            this.lastSelect.val(this.eq(arg1));
            this.nextTest();
        }));
    },
    
    blur: function Test$blur(select, value) {
        /// <param name="select" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Test"></returns>
        if (arguments.length === 1) {
            this.waitFor(select);
        }
        else if (arguments.length === 2) {
            this.waitFor(select, value);
        }
        return this.step('Blur', ss.Delegate.create(this, function() {
            if (this.lastSelect == null) {
                this.abort();
            }
            this.lastSelect.blur();
            this.nextTest();
        })).waitIO();
    },
    
    focus: function Test$focus(select, value) {
        /// <param name="select" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Test"></returns>
        if (arguments.length === 1) {
            this.waitFor(select);
        }
        else if (arguments.length === 2) {
            this.waitFor(select, value);
        }
        return this.step('Focus', ss.Delegate.create(this, function() {
            if (this.lastSelect == null) {
                this.abort();
            }
            this.lastSelect.focus();
            this.nextTest();
        })).waitIO();
    },
    
    press: function Test$press(select, value) {
        /// <param name="select" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Test"></returns>
        if (arguments.length === 1) {
            this.waitFor(select);
        }
        else if (arguments.length === 2) {
            this.waitFor(select, value);
        }
        return this.step('Press', select, value, ss.Delegate.create(this, function() {
            if (this.lastSelect == null) {
                this.abort();
            }
            this.lastSelect.focus().trigger('mousedown').click().trigger('mouseup');
            this.nextTest();
        })).waitIO();
    },
    
    mouseDown: function Test$mouseDown(select, value) {
        /// <param name="select" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Test"></returns>
        if (arguments.length === 1) {
            this.waitFor(select);
        }
        else if (arguments.length === 2) {
            this.waitFor(select, value);
        }
        return this.step('MouseDown', ss.Delegate.create(this, function() {
            if (this.lastSelect == null) {
                this.abort();
            }
            this.lastSelect.focus().trigger('mousedown');
            this.nextTest();
        })).waitIO();
    },
    
    mouseOver: function Test$mouseOver(select, value) {
        /// <param name="select" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Test"></returns>
        if (arguments.length === 1) {
            this.waitFor(select);
        }
        else if (arguments.length === 2) {
            this.waitFor(select, value);
        }
        return this.step('MouseOver', ss.Delegate.create(this, function() {
            if (this.lastSelect == null) {
                this.abort();
            }
            this.lastSelect.focus().trigger('mouseover').trigger('mouseenter');
            this.nextTest();
        })).waitIO();
    },
    
    keyCode: function Test$keyCode(code) {
        /// <param name="code" type="Number" integer="true">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('KeyCode', code, ss.Delegate.create(this, function() {
            code = parseInt(this.eq(code).toString());
            if (this.lastSelect == null) {
                this.abort();
            }
            this.lastSelect.focus();
            var ev1 = jQuery.Event("keydown");
            ev1.which = code;
            this.lastSelect.trigger(ev1);
            var ev2 = jQuery.Event("keypress");
            ev2.which = code;
            this.lastSelect.trigger(ev2);
            var ev3 = jQuery.Event("keyup");
            ev3.which = code;
            this.lastSelect.trigger(ev3);
            this.nextTest();
        }));
    },
    
    deleteRecord: function Test$deleteRecord(partitionKey, rowKey) {
        /// <param name="partitionKey" type="String">
        /// </param>
        /// <param name="rowKey" type="String">
        /// </param>
        /// <returns type="Test"></returns>
        return this.step('DeleteRecord', partitionKey + '/' + rowKey, ss.Delegate.create(this, function() {
            FileBlobBase.deleteItemAw(this, partitionKey, rowKey);
        }));
    }
}


Type.registerNamespace('MetaTests.Classes');

////////////////////////////////////////////////////////////////////////////////
// TestListMenu

TestListMenu = function TestListMenu(el, nameList, handler) {
    /// <param name="el" type="jQueryObject">
    /// </param>
    /// <param name="nameList" type="Object">
    /// </param>
    /// <param name="handler" type="Nsb.Classes.Function">
    /// </param>
    TestListMenu.initializeBase(this, [ el, nameList, handler ]);
}


////////////////////////////////////////////////////////////////////////////////
// TestSuite

TestSuite = function TestSuite(name) {
    /// <param name="name" type="String">
    /// </param>
    /// <field name="allTestsName" type="String" static="true">
    /// </field>
    /// <field name="suites" type="Object" static="true">
    /// </field>
    /// <field name="teller" type="jQueryObject" static="true">
    /// </field>
    /// <field name="name" type="String">
    /// </field>
    /// <field name="tests" type="Object">
    /// </field>
    this.tests = {};
    this.name = name;
    TestSuite.suites[name.toLowerCase()] = this;
}
TestSuite.runMasterSuite = function TestSuite$runMasterSuite() {
    var suite = TestSuite.getTestSuiteByPage(ThemeYoshi.defaultPageName);
    suite.run('Run all tests');
}
TestSuite.getTestSuiteByPage = function TestSuite$getTestSuiteByPage(pageName) {
    /// <param name="pageName" type="String">
    /// </param>
    /// <returns type="TestSuite"></returns>
    var parts = pageName.split('.');
    pageName = parts[parts.length - 1];
    var className = 'MetaTests.Pages.' + pageName + 'Tests';
    var keyName = pageName.toLowerCase();
    try {
        if (Type.isClass(Type.getType(className))) {
            if (Object.keyExists(TestSuite.suites, keyName)) {
                return TestSuite.suites[keyName];
            }
            return eval('new ' + className + '()');
        }
    }
    catch ($e1) {
    }
    Inform.trace('Missing test suite for page {0}', className);
    return null;
}
TestSuite.tell = function TestSuite$tell(msg) {
    /// <param name="msg" type="String">
    /// </param>
    /// <returns type="jQueryObject"></returns>
    if (TestSuite.teller != null) {
        if (!String.isNullOrEmpty(msg)) {
            TestSuite.teller.html(msg).show();
        }
        else {
            TestSuite.teller.html('').hide();
        }
    }
    return TestSuite.teller;
}
TestSuite.prototype = {
    name: null,
    
    run: function TestSuite$run(test) {
        /// <param name="test" type="String">
        /// </param>
        this.runAw(null, test);
    },
    
    runAw: function TestSuite$runAw(awp, test) {
        /// <param name="awp" type="Await">
        /// </param>
        /// <param name="test" type="String">
        /// </param>
        var tt = this.tests[test.toLowerCase()];
        if (tt != null) {
            tt._suite = this;
            tt.reset().runTest(awp);
        }
        else {
            Inform.error('Could not find test {0}', test);
            if (awp != null) {
                awp.done();
            }
        }
    },
    
    testList: function TestSuite$testList() {
        /// <returns type="Object"></returns>
        return DropMenu.listify(this.tests, function(a, b) {
            return String.compare((a).name, (b).name, true);
        }, function(dd, o) {
            dd[(o).name] = (o).name;
        });
    },
    
    runAllAw: function TestSuite$runAllAw(awp) {
        /// <param name="awp" type="Await">
        /// </param>
        this.runAw(awp, 'Run all tests');
    }
}


Test.registerClass('Test', Await);
TestListMenu.registerClass('TestListMenu', DropMenu);
TestSuite.registerClass('TestSuite');
Test.defaultTestSpeed = 1;
Test.waitSleep = 13;
Test.maxWait = 10000;
Test.hasContent = '[HasContent]';
Test.isEmpty = '[IsEmpty]';
Test.isNumber = '[IsNumber]';
Test.askOkBtn = '.Ask .OkBtn';
Test.askCancelBtn = '.Ask .CancelBtn';
Test.testSpeed = 1;
Test._indent$1 = '';
Test._savedSpeeds$1 = [];
Test.testUserId = null;
Test.testVars = {};
Test._rxNumber$1 = new RegExp('^[-+]?\\d+(\\.\\d+)?$');
Test._instances$1 = {};
TestSuite.allTestsName = 'Run all tests';
TestSuite.suites = {};
TestSuite.teller = null;
})();

//! This script was generated using Script# v0.7.4.0
